import axios from 'axios'
import { ElMessage } from 'element-plus'
//sino更新
// 创建axios实例
// create an axios instance
const service = axios.create({
    baseURL: process.env.NODE_ENV === 'development' ? '/dev' : '', // url = base url + request url
    withCredentials: false, // send cookies when cross-domain requests
    timeout: 10000, // request timeout
})

// 请求拦截器
service.interceptors.request.use(
    (config: any) => {
        config.headers['jnpf-origin'] = 'pc'
        config.headers['Authorization'] = localStorage.getItem('jnpf_token')?.split('|')[0]
        if (config.method == 'get') {
            config.params = config.data
        }
        let timestamp = Date.now()
        if (config.url.indexOf('?') > -1) {
            config.url += `&n=${timestamp}`
        } else {
            config.url += `?n=${timestamp}`
        }
        return config
    },
    (error: any) => {
        // do something with request error
        if (process.env.NODE_ENV === 'development') {
            console.log(error) // for debug
        }
        return Promise.reject(error)
    }
)
// 响应拦截器
service.interceptors.response.use(
    (response: any) => {
        const res = response.data
        if (res.code !== 200) {
            ElMessage({
                message:res.msg,
                type:'error'
            })
            return Promise.reject(new Error(res.msg || 'Error'))
        } else {
            return res
        }
    },
    (error: any) => {
        // 统一处理错误
        return Promise.reject(error)
    }
)
export default service
//封装 get 请求
export function get<T>(url: string, token?: string): Promise<T> {
    let header: any;
    if (token) {
        header = {
            'Content-Type': 'application/json',
            'Authorization': token
        }
    } else {
        header = {
            'Content-Type': 'application/json',
        }
    }

    return fetch(url, { headers: header })
    .then(response => {
        if (!response.ok) { // 如果响应状态码不在200-299之间，‌则认为响应不ok
          if (response.status === 400) { 
            throw new Error('发送的请求报文有语法错误，‌服务器无法理解'); 
          } else if (response.status === 401) { 
            throw new Error('发送的请求未通过身份验证，‌需要授权'); 
          }else if (response.status === 403) { 
            throw new Error('服务器收到了客户端的请求，‌但由于某些原因拒绝提供服务'); 
          }else if (response.status === 404) { 
            throw new Error('无法找到请求的资源'); 
          } else if (response.status === 500) { // 如果是服务器内部错误
            throw new Error('服务器内部错误,请检查'); // 返回特定的错误信息
          } else {
            throw new Error('其他服务器错误'); // 对于其他服务器错误，‌可以统一返回一个通用的错误信息
          }
        }
        return response.json(); // 如果响应ok，‌则解析json数据
      })
      .catch(error => {
        // 处理所有其他类型的错误，‌例如网络错误、‌CORS问题等
        if(error instanceof TypeError&&error.message.includes('network')){
          throw new Error('网络错误，‌请检查您的网络连接'); 
        }else if(error instanceof TypeError&&error.message.includes('CORS')||error.message.includes('cors')){
            throw new Error('跨域错误，‌请检查您的请求地址');
        }else if (error instanceof TypeError) {
            throw new Error('获取数据失败，请检查'); 
          } else {
            throw new Error(error); 
          }
      });
}
//封装 get无token 请求
export function getNoToken<T>(url: string): Promise<T> {
    let header: any;
    return fetch(url, { headers: header })
    .then(response => {
        if (!response.ok) { // 如果响应状态码不在200-299之间，‌则认为响应不ok
          if (response.status === 400) { 
            throw new Error('发送的请求报文有语法错误，‌服务器无法理解'); 
          } else if (response.status === 401) { 
            throw new Error('发送的请求未通过身份验证，‌需要授权'); 
          }else if (response.status === 403) { 
            throw new Error('服务器收到了客户端的请求，‌但由于某些原因拒绝提供服务'); 
          }else if (response.status === 404) { 
            throw new Error('无法找到请求的资源'); 
          } else if (response.status === 500) { // 如果是服务器内部错误
            throw new Error('服务器内部错误,请检查'); // 返回特定的错误信息
          } else {
            throw new Error('其他服务器错误'); // 对于其他服务器错误，‌可以统一返回一个通用的错误信息
          }
        }
        return response.json(); // 如果响应ok，‌则解析json数据
      })
      .catch(error => {
        // 处理所有其他类型的错误，‌例如网络错误、‌CORS问题等
        if(error instanceof TypeError&&error.message.includes('network')){
          throw new Error('网络错误，‌请检查您的网络连接'); 
        }else if(error instanceof TypeError&&error.message.includes('CORS')||error.message.includes('cors')){
            throw new Error('跨域错误，‌请检查您的请求地址');
        }else if (error instanceof TypeError) {
            throw new Error('获取数据失败，请检查'); 
          } else {
            throw new Error(error); 
          }
      });
}
//封装 get需要Bearer+token 请求
export function getWithCookie<T>(url: string, token: string): Promise<T> {
    let header = {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer ' + token
    } as any

    return fetch(url, { headers: header })
    .then(response => {
        if (!response.ok) { // 如果响应状态码不在200-299之间，‌则认为响应不ok
          if (response.status === 400) { 
            throw new Error('发送的请求报文有语法错误，‌服务器无法理解'); 
          } else if (response.status === 401) { 
            throw new Error('发送的请求未通过身份验证，‌需要授权'); 
          }else if (response.status === 403) { 
            throw new Error('服务器收到了客户端的请求，‌但由于某些原因拒绝提供服务'); 
          }else if (response.status === 404) { 
            throw new Error('无法找到请求的资源'); 
          } else if (response.status === 500) { // 如果是服务器内部错误
            throw new Error('服务器内部错误,请检查'); // 返回特定的错误信息
          } else {
            throw new Error('其他服务器错误'); // 对于其他服务器错误，‌可以统一返回一个通用的错误信息
          }
        }
        return response.json(); // 如果响应ok，‌则解析json数据
      })
      .catch(error => {
        // 处理所有其他类型的错误，‌例如网络错误、‌CORS问题等
        if(error instanceof TypeError&&error.message.includes('network')){
          throw new Error('网络错误，‌请检查您的网络连接'); 
        }else if(error instanceof TypeError&&error.message.includes('CORS')||error.message.includes('cors')){
            throw new Error('跨域错误，‌请检查您的请求地址');
        }else if (error instanceof TypeError) {
            throw new Error('获取数据失败，请检查'); 
          } else {
            throw new Error(error); 
          }
      });
}

// 封装 POST 请求
export function post<T>(url: string, data: any, token?: any): Promise<T> {
    let header: any;
    if (token) {
        header = {
            'Content-Type': 'application/json',
            'Authorization': token
        }
    } else {
        header = {
            'Content-Type': 'application/json',
        }
    }

    return fetch(url, {
        method: 'POST',
        headers: header,
        body: JSON.stringify(data)
    })
    .then(response => {
        if (!response.ok) { // 如果响应状态码不在200-299之间，‌则认为响应不ok
          if (response.status === 400) { 
            throw new Error('发送的请求报文有语法错误，‌服务器无法理解'); 
          } else if (response.status === 401) { 
            throw new Error('发送的请求未通过身份验证，‌需要授权'); 
          }else if (response.status === 403) { 
            throw new Error('服务器收到了客户端的请求，‌但由于某些原因拒绝提供服务'); 
          }else if (response.status === 404) { 
            throw new Error('无法找到请求的资源'); 
          } else if (response.status === 500) { // 如果是服务器内部错误
            throw new Error('服务器内部错误,请检查'); // 返回特定的错误信息
          } else {
            throw new Error('其他服务器错误'); // 对于其他服务器错误，‌可以统一返回一个通用的错误信息
          }
        }
        return response.json(); // 如果响应ok，‌则解析json数据
      })
      .catch(error => {
        // 处理所有其他类型的错误，‌例如网络错误、‌CORS问题等
        if(error instanceof TypeError&&error.message.includes('network')){
          throw new Error('网络错误，‌请检查您的网络连接'); 
        }else if(error instanceof TypeError&&error.message.includes('CORS')||error.message.includes('cors')){
            throw new Error('跨域错误，‌请检查您的请求地址');
        }else if (error instanceof TypeError) {
            throw new Error('获取数据失败，请检查'); 
          } else {
            throw new Error(error); 
          }
      });
}
// 封装 PUT 请求
export function put<T>(url: string, data: any, token?: string): Promise<T> {
    let header: any
    if (token) {
        header = {
            'Content-Type': 'application/json',
            'Authorization': 'Bearer ' + token
        }
    } else {
        header = {
            'Content-Type': 'application/json',
            // 'Authorization': localStorage.getItem('token')
        }
    }
    return fetch(url, {
        method: 'PUT',
        headers: header,
        body: JSON.stringify(data)
    })
    .then(response => {
        if (!response.ok) { // 如果响应状态码不在200-299之间，‌则认为响应不ok
          if (response.status === 400) { 
            throw new Error('发送的请求报文有语法错误，‌服务器无法理解'); 
          } else if (response.status === 401) { 
            throw new Error('发送的请求未通过身份验证，‌需要授权'); 
          }else if (response.status === 403) { 
            throw new Error('服务器收到了客户端的请求，‌但由于某些原因拒绝提供服务'); 
          }else if (response.status === 404) { 
            throw new Error('无法找到请求的资源'); 
          } else if (response.status === 500) { // 如果是服务器内部错误
            throw new Error('服务器内部错误,请检查'); // 返回特定的错误信息
          } else {
            throw new Error('其他服务器错误'); // 对于其他服务器错误，‌可以统一返回一个通用的错误信息
          }
        }
        return response.json(); // 如果响应ok，‌则解析json数据
      })
      .catch(error => {
        // 处理所有其他类型的错误，‌例如网络错误、‌CORS问题等
        if(error instanceof TypeError&&error.message.includes('network')){
          throw new Error('网络错误，‌请检查您的网络连接'); 
        }else if(error instanceof TypeError&&error.message.includes('CORS')||error.message.includes('cors')){
            throw new Error('跨域错误，‌请检查您的请求地址');
        }else if (error instanceof TypeError) {
            throw new Error('获取数据失败，请检查'); 
          } else {
            throw new Error(error); 
          }
      });
}





  
  